﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using SistemaInventarioMVC.Models.Entidades;
using SistemaInventarioMVC.Models.Context;

namespace SistemaInventarioMVC.Models.Repository
{
    public class UnitOfWork : IDisposable
    {
        private SistemaInventarioDbContext context = null;
        private GenericRepository<Almacen> _almacenRepository;
        private GenericRepository<Familia> _familiaRepository;
        private GenericRepository<Inventario> _inventarioRepository;
        private GenericRepository<Marca> _marcaRepository;
        private GenericRepository<RazonEntrada> _razonEntradaReposity;
        private GenericRepository<RazonSalida> _razonSalidaRepository;
        private GenericRepository<TipoProducto> _tipoProductoRepository;
        private GenericRepository<Ubicacion> _ubicacionRepository;
        private GenericRepository<UnidadMedida> _unidadMedidaRepository;
        private GenericRepository<Articulo> _articuloRepository;
        private GenericRepository<CabeceraEntradaAlmacen> _cabeceraEntradaRepository;
        private GenericRepository<CabeceraSalidaAlmacen> _cabeceraSalidaRepository;
        private GenericRepository<DetalleEntradaAlmacen> _detalleEntradaRepository;
        private GenericRepository<DetalleSalidaAlmancen> _detalleSalidaRepository;
        private Boolean disposed;

        public UnitOfWork() 
        {
            context = new SistemaInventarioDbContext();
            disposed = false;
        }

        public void Save() 
        {
            context.SaveChanges();
        }

        public GenericRepository<Almacen> Almacen
        {
            get 
            {
                if (_almacenRepository == null)
                {
                    _almacenRepository = new GenericRepository<Almacen>(context);
                }
                return _almacenRepository; 
            }
            
        }

        public GenericRepository<Familia> Familia
        {
            get 
            {
                if (_familiaRepository == null)
                {
                    _familiaRepository = new GenericRepository<Familia>(context);
                }
                return _familiaRepository; 
            }
        }

        public GenericRepository<Inventario> Inventario
        {
            get 
            {
                if (_inventarioRepository == null)
                {
                    _inventarioRepository = new GenericRepository<Inventario>(context);
                }
                return _inventarioRepository; 
            }
        }

        public GenericRepository<Marca> Marca
        {
            get 
            {
                if (_marcaRepository == null)
                {
                    _marcaRepository = new GenericRepository<Marca>(context);
                }
                return _marcaRepository;
            }
        }

        public GenericRepository<RazonEntrada> RazonEntrada
        {
            get 
            {
                if (_razonEntradaReposity == null)
                {
                    _razonEntradaReposity = new GenericRepository<RazonEntrada>(context);
                }
                return _razonEntradaReposity; 
            }
        }

        public GenericRepository<RazonSalida> RazonSalida
        {
            get 
            {
                if (_razonSalidaRepository == null)
                {
                    _razonSalidaRepository = new GenericRepository<RazonSalida>(context);
                }
                return _razonSalidaRepository; 
            }
        }

        public GenericRepository<TipoProducto> TipoProducto
        {
            get 
            {
                if (_tipoProductoRepository == null)
                {
                    _tipoProductoRepository = new GenericRepository<TipoProducto>(context);
                }
                return _tipoProductoRepository;
            }
        }

        public GenericRepository<Ubicacion> Ubicacion
        {
            get 
            {
                if (_ubicacionRepository == null)
                {
                    _ubicacionRepository = new GenericRepository<Ubicacion>(context); 
                }
                return _ubicacionRepository; 
            }
        }

        public GenericRepository<UnidadMedida> UnidadMedida
        {
            get 
            {
                if (_unidadMedidaRepository == null)
                {
                    _unidadMedidaRepository = new GenericRepository<UnidadMedida>(context);
                }
                return _unidadMedidaRepository;
            }
        }

        public GenericRepository<Articulo> Articulo
        {
            get
            {
                if (_articuloRepository == null)
                {
                    _articuloRepository = new GenericRepository<Articulo>(context);
                }
                return _articuloRepository;
            }
        }

        public GenericRepository<CabeceraEntradaAlmacen> CabeceraEntradaAlmacen
        {
            get 
            {
                if (_cabeceraEntradaRepository == null)
                {
                    _cabeceraEntradaRepository = new GenericRepository<CabeceraEntradaAlmacen>(context);
                }
                return _cabeceraEntradaRepository; 
            }
        }
        
        public GenericRepository<CabeceraSalidaAlmacen> CabeceraSalidaAlmacen
        {
            get
            {
                if (_cabeceraSalidaRepository == null)
                {
                    _cabeceraSalidaRepository = new GenericRepository<CabeceraSalidaAlmacen>(context);
                }
                return _cabeceraSalidaRepository; 
            }
        }
        
        public GenericRepository<DetalleEntradaAlmacen> DetalleEntradaAlmacen
        {
            get 
            {
                if (_detalleEntradaRepository == null)
                {
                    _detalleEntradaRepository = new GenericRepository<DetalleEntradaAlmacen>(context);
                }
                return _detalleEntradaRepository; 
            }
        }
        
        public GenericRepository<DetalleSalidaAlmancen> DetalleSalidaRepository
        {
            get 
            {
                if (_detalleSalidaRepository == null)
                {
                    _detalleSalidaRepository = new GenericRepository<DetalleSalidaAlmancen>(context);
                }
                return _detalleSalidaRepository; 
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        public virtual void Dispose(Boolean disposing) 
        {
            if (!disposed)
            {
                if (disposing)
                {
                    context.Dispose();
                }
            }
        }
    }
}